home *** CD-ROM | disk | FTP | other *** search
/ Suzy B Software 2 / Suzy B Software CD-ROM 2 (1994).iso / extras / falcon / scrdump / source / sdump.c < prev    next >
C/C++ Source or Header  |  1995-04-27  |  14KB  |  653 lines
  1. #include <tos.h>
  2. #include <gem.h>
  3. #include <vdi.h>
  4. #include <string.h>
  5. #include <stdlib.h>
  6.  
  7. #include "sdump.h"
  8.  
  9. #ifdef GEMDUMP                            /* anpassung für GEMDUMP */
  10.  
  11. #    include "gemdump.rsh"                /* resourcen */
  12. #    include "gemdump.h"
  13.  
  14.     extern XINST inst;                    /* definiert in gd_start.s */
  15.     extern int ev_time;
  16.     extern int althelp;
  17.     extern long ah_time;
  18.     int scr_nr;
  19.      int evnts=MU_MESAG;
  20.  
  21.     int do_store_img(char *name,MFDB *buffer,int wid,int hght,COLOR *col,int xflag);
  22.     void make_name(char *name);
  23.     long do_init_vbl(void),do_exit_vbl(void);
  24.  
  25. #    define init_vbl()        Supexec(do_init_vbl)
  26. #    define exit_vbl()        Supexec(do_exit_vbl)
  27.  
  28. #    define _store_img        do_store_img
  29. #    define _make_name        make_name
  30. #    define MENUE_ENTRY        "  GEM-Dump"
  31. #    define PARAM_SAVE        "C:\\GEMDUMP.ACC"
  32. #    define PARAM_EXT        "*.ACC"
  33. #    define PAR_OFF            32
  34.  
  35. #else                                    /* anpassung für SCRDUMP */
  36.  
  37. #    include "scrdump.rsh"                /* resourcen */
  38. #    include "scrdump.h"
  39.  
  40. #    define inst                dump->inst
  41. #    define scr_nr            dump->nr
  42. #    define _store_img        dump->store_img
  43. #    define _make_name        dump->make_name
  44. #    define MENUE_ENTRY        "  ScreenDump"
  45. #    define PARAM_SAVE        "C:\\AUTO\\XALTHELP.PRG"
  46. #    define PARAM_EXT        "*.PRG"
  47. #    define PAR_OFF            30
  48. #endif
  49.  
  50. OBJECT *dialog;                            /* globale variable */
  51. int handle,dummy;
  52. int planes,screen_w,screen_h;
  53.  
  54. /*
  55.     cookie-routine
  56.         get_cookie liefert zeiger zu cookie mit id 'cookie' oder 0l falls nicht gefunden
  57. */
  58. typedef struct
  59. {
  60.     long    id,
  61.             *ptr;
  62. } COOKJAR;
  63.  
  64. long *get_cookie(long cookie)    
  65. {
  66. long    sav;
  67. COOKJAR    *cookiejar;
  68. int    i = 0;
  69.  
  70.     sav=Super((void *)1L);
  71.     if ( sav==0L )
  72.         sav=Super(0L);
  73.  
  74.     cookiejar=*((COOKJAR **)0x05a0l);
  75.  
  76.     if ( sav!=-1L )
  77.         Super((void *)sav);
  78.  
  79.     if ( cookiejar ) {
  80.         while ( cookiejar[i].id ) {
  81.             if ( cookiejar[i].id==cookie )
  82.                 return cookiejar[i].ptr;
  83.             i++;
  84.         }
  85.     }
  86.     return 0l;
  87. }
  88.  
  89. /*
  90.     clipping für fenster
  91. */
  92. #define min(a,b)    ((a)<(b))?(a):(b)
  93. #define max(a,b)    ((a)>(b))?(a):(b)
  94.  
  95. int check_recs(int x,int y,int dx,int dy,int *x1,int *y1,int *dx1,int *dy1)
  96. {        /* 'clippt' rechteck in x1,y1,dx1,dy1 mit rechteck in x,y,dx,dy */
  97.         /* rückgabe: TRUE falls rechteck übrigbleibt, sonst FALSE */
  98. int hx1,hy1,hx2,hy2;
  99.  
  100.     hx2=min(x+dx,*x1+*dx1);
  101.     hy2=min(y+dy,*y1+*dy1);
  102.     hx1=max(x,*x1);
  103.     hy1=max(y,*y1);
  104.     *x1=hx1; *y1=hy1;
  105.     *dx1=hx2-hx1; *dy1=hy2-hy1;
  106.     return (hx2>hx1)&&(hy2>hy1);
  107. }
  108.  
  109. /*
  110.     erzeuge puffer mit grö₧e dx/dy in MFDB help
  111.     gebe länge zurück falls erfolgreich
  112.     sonst 0l
  113. */
  114. long set_fdb(int dx,int dy,MFDB *help)
  115. {
  116. long len;
  117.  
  118.     help->fd_w=dx;
  119.     help->fd_h=dy; 
  120.     help->fd_wdwidth=help->fd_w/16;
  121.     if ( dx&15 )
  122.         help->fd_wdwidth++;
  123.     help->fd_nplanes=planes;
  124.     help->fd_stand=0;
  125.     help->fd_r1=help->fd_r2=help->fd_r3=0;
  126.  
  127.     len=(long)help->fd_wdwidth*2l*(long)help->fd_h*(long)planes;
  128.     help->fd_addr=Malloc(len);
  129.     if ( help->fd_addr )
  130.         return len;
  131.     return 0;
  132. }
  133.  
  134. /*
  135.     draw_objc
  136.     undraw_objc
  137.         zeichne dialog mit pufferung des hintergrundes (falls möglich)
  138. */
  139. int draw_objc(OBJECT *objc_addr,int *x,int *y,int *dx,int *dy,MFDB *buffer)
  140. {
  141. int xy[8];
  142. int ret;
  143. MFDB screen;
  144.  
  145.     form_center(objc_addr, x,y,dx,dy);
  146.     buffer->fd_addr=0L;
  147.     screen.fd_addr=0L;
  148.  
  149.     if ( set_fdb(*dx+1,*dy+1,buffer) ) {
  150.         check_recs(0,0,screen_w,screen_h,x,y,dx,dy);
  151.         xy[0]=*x; xy[1]=*y; xy[2]=*x+*dx; xy[3]=*y+*dy;
  152.         xy[4]=0; xy[5]=0; xy[6]=*dx; xy[7]=*dy;
  153.         v_hide_c(handle);
  154.         vro_cpyfm(handle,3,xy,&screen,buffer);
  155.         v_show_c(handle,1);
  156.         ret=1;
  157.     }
  158.     if ( buffer->fd_addr==0L ) {
  159.         form_dial(FMD_START, *x,*y,*dx,*dy, *x,*y,*dx,*dy);
  160.         ret=0;
  161.     }
  162.     objc_draw(objc_addr, 0,5, *x,*y,*dx,*dy);
  163.     return(ret);
  164. }
  165.  
  166. void undraw_objc(int x,int y,int dx,int dy,MFDB *buffer,int flag)
  167. {
  168. int xy[8];
  169. MFDB screen;
  170.  
  171.     if ( flag ) {
  172.         screen.fd_addr=0L;
  173.         xy[0]=0; xy[1]=0; xy[2]=dx; xy[3]=dy;
  174.         xy[4]=x; xy[5]=y; xy[6]=x+dx; xy[7]=y+dy;
  175.         v_hide_c(handle);
  176.         vro_cpyfm(handle,3,xy,buffer,&screen);
  177.         v_show_c(handle,1);
  178.         Mfree(buffer->fd_addr);
  179.     }
  180.     else {
  181.         form_dial(FMD_FINISH, x,y,dx,dy, x,y,dx,dy);
  182.     }
  183. }
  184.  
  185. /*
  186.     initialisiere vdi
  187. */
  188. void init_vdi(void)
  189. {
  190. int i;
  191. int work_in[12],work_out[58];
  192.  
  193.      handle=graf_handle(&dummy,&dummy,&dummy,&dummy);
  194.      for ( i=0; i<10; i++ )
  195.          work_in[i]=1;
  196.      work_in[10]=2;
  197.  
  198.      v_opnvwk(work_in,&handle,work_out);
  199.  
  200.     screen_w=work_out[0]+1;
  201.     screen_h=work_out[1]+1;
  202. /*
  203.     pix_wid=work_out[3];        /* should be used in save-img */
  204.     pix_hght=work_out[4];        /* not yet implemented */
  205. */
  206.  
  207.     vq_extnd(handle,1,work_out);
  208.     planes=work_out[4];
  209. }
  210.  
  211. #ifdef GEMDUMP                            /* spezielle routinen für GEMDUMP */
  212.  
  213. /*
  214.     lese 200Hz-Zähler aus
  215. */
  216. static long _gettimer(void)
  217. {
  218.     return *(long*)0x4BA;
  219. }
  220. long gettimer(void)
  221. {
  222.     return Supexec(_gettimer);
  223. }
  224.  
  225. /*
  226.     ermittle konvertierungstabelle für farben
  227. */
  228. void get_conv_tab(char *conv_tab)
  229. {
  230. int i,j;
  231. unsigned int c;
  232. int set,col;
  233. int ger_buf[8],std_buf[8];
  234. int xy[]={0,0,0,0,0,0,0,0};
  235. MFDB screen={0,0,0,0,0,0,0,0,0},
  236.      ger=    {0,1,1,1,0,0,0,0,0},
  237.      std=    {0,1,1,1,1,0,0,0,0};
  238.  
  239.     vswr_mode(handle,MD_REPLACE);
  240.     vsm_type(handle,1);
  241.     vsm_height(handle,1);
  242.     wind_update(BEG_UPDATE);
  243.  
  244.     v_get_pixel(handle,0,0,&set,&col);
  245.  
  246.     ger.fd_nplanes=std.fd_nplanes=planes;
  247.     ger.fd_addr=ger_buf;
  248.     std.fd_addr=std_buf;
  249.  
  250.     for ( i=0; i<(1<<planes); i++ ) {
  251.         vsm_color(handle,i);
  252.         v_pmarker(handle,1,xy);
  253.         vro_cpyfm(handle,S_ONLY,xy,&screen,&ger);
  254.         vr_trnfm(handle,&ger,&std);
  255.         conv_tab[i]=0;
  256.         for ( j=0; j<planes; j++ ) {
  257.             c=std_buf[j];
  258.             c>>=15;
  259.             c<<=j;
  260.             conv_tab[i]|=(char)c;
  261.         }
  262.     }
  263.  
  264.     if ( set )
  265.         vsm_color(handle,col);
  266.     else
  267.         vsm_color(handle,WHITE);
  268.  
  269.     v_pmarker(handle,1,xy);
  270.     wind_update(END_UPDATE);
  271. }
  272.  
  273. /*
  274.     lese farben ein
  275. */
  276. void get_colors(COLOR *col)
  277. {
  278. char conv_tab[256];
  279. int i;
  280.  
  281.     get_conv_tab(conv_tab);
  282.     for ( i=0; i<(1<<planes); i++ )
  283.         vq_color(handle,i,0,(int*)&col[conv_tab[i]]);
  284. }
  285.  
  286. /*
  287.     speichere den ganzen bildschirm (gem-konform)
  288. */
  289. int gem_screen(void)
  290. {
  291. MFDB std,buffer,screen;
  292. long len;
  293. COLOR colors[256];
  294. char name[64];
  295. int xy[8];
  296. int err;
  297.  
  298.     _make_name(name);
  299.     err=-39;                            /* speicherfehler */
  300.                                         /* (wird überschrieben, wenn er nicht eintritt */
  301.  
  302.                                         /* puffer für screen anlegen */
  303.     if ( (len=set_fdb(screen_w,screen_h,&buffer))!=0l ) {
  304.         memset(buffer.fd_addr,0,len);
  305.         screen.fd_addr=0l;
  306.         xy[0]=xy[1]=xy[4]=xy[5]=0;
  307.         xy[2]=xy[6]=screen_w-1;
  308.         xy[3]=xy[7]=screen_h-1;
  309.                                         /* kopiere screen */
  310.         vro_cpyfm(handle,3,xy,&screen,&buffer);
  311.                                         /* zweiter puffer zum konvertieren */
  312.                                         /* (vr_trnfm geht nicht mit screen als quelle) */
  313.         if ( set_fdb(screen_w,screen_h,&std)!=0l ) {
  314.             std.fd_stand=1;
  315.                                         /* konvertieren */
  316.             vr_trnfm(handle,&buffer,&std);
  317.             if ( inst.ximg )
  318.                 get_colors(colors);
  319.                                         /* und speichern */
  320.             err=_store_img(name,&std,screen_w,screen_h,colors,inst.ximg);
  321.             Mfree(std.fd_addr);
  322.         }
  323.         Mfree(buffer.fd_addr);
  324.     }
  325.     return err;
  326. }
  327. #endif
  328.  
  329. /*
  330.     rufe dateiselector auf
  331. */
  332. int fsel(char *path,char *sel,int *button,char *label)
  333. {
  334. int h;
  335.  
  336.     if ( *path==0 ) {
  337.         *path=Dgetdrv()+'A';
  338.         strcpy(path+1,":\\*.*");
  339.     }
  340.  
  341.     if ( _GemParBlk.global[0]>=0x130 )
  342.         h=fsel_exinput(path,sel,button,label);
  343.     else
  344.         h=fsel_input(path,sel,button);
  345.  
  346.     if ( h==0 )        /* fehler -> abbruch */
  347.         *button=0;
  348.  
  349.     return h;
  350. }
  351.  
  352. /*
  353.     hole dateinamen via fileselector
  354. */
  355. int get_name(char *name,char *ext,char *label)
  356. {
  357. char path[64],file[32],*h;
  358. int button;
  359.  
  360.     strcpy(path,name);
  361.     h=strrchr(path,'\\');
  362.     if ( h ) {
  363.         h++;
  364.         strcpy(file,h);
  365.         *h=0;
  366.         strcat(path,ext);
  367.     }
  368.     else
  369.         *file=0;
  370.  
  371.     fsel(path,file,&button,label);
  372.  
  373.     if ( button ) {
  374.         strcpy(name,path);
  375.         h=strrchr(path,'\\');
  376.         if ( h ) 
  377.             h++;
  378.         else
  379.             h=file;
  380.         strcpy(h,file);
  381.         return 1;
  382.     }
  383.     return 0;
  384. }
  385.  
  386. /*
  387.     haupt-routine nach acc/prg aufruf
  388. */
  389. void do_work(void)
  390. {
  391. int ret,err;
  392. int x,y,w,h,flag;
  393. MFDB buffer,screen;
  394. char name[64];
  395. #ifndef GEMDUMP
  396.     SCREEN_DUMP *dump;                    /* zeiger auf cookie */
  397. #endif
  398.  
  399.     init_vdi();                            /* init vdi */
  400.                                         /* setzt screen_w,screen_h,planes */
  401.       screen.fd_addr=0l;
  402.  
  403. #ifndef GEMDUMP
  404.                                         /* cookie suchen */
  405.     dump=(SCREEN_DUMP*)get_cookie('SDMP');
  406.                                         /* kein keks da, falscher keks? */
  407.     if ( !dump || dump->magic!='TMMW' ) {
  408.         form_alert(1,"[3][ | Cookie nicht gefunden! | ][Abbruch]");
  409.         return;                            /* und tschüss */
  410.     }
  411. #endif
  412.                                         /* dialog voreinstellen */
  413.     strcpy(objc_tedstr(dialog,PATH),inst.file);
  414.     if ( inst.ximg )
  415.         objc_select(dialog,XIMG);
  416.     else
  417.         objc_unselect(dialog,XIMG);
  418.     objc_unselect(dialog,RESET);
  419. #ifdef GEMDUMP
  420.     if ( inst.althelp )
  421.         objc_select(dialog,ALTHELP);
  422.     else
  423.         objc_unselect(dialog,ALTHELP);
  424. #endif
  425.  
  426.     wind_update(BEG_UPDATE);
  427.                                         /* zeichne dialog */
  428.     flag=draw_objc(dialog,&x,&y,&w,&h,&buffer);
  429.     do {                                /* bearbeite dialog */
  430.         ret=form_do(dialog,0)&0x7FFF;
  431.         if ( ret==SELECT ) {            /* namen via fsel eingeben */
  432.           char *c,*t=objc_tedstr(dialog,PATH);
  433.  
  434.             objc_unselect(dialog,SELECT);
  435.             if ( get_name(t,"*.IMG","Pfad für ScreenDump einstellen") ) {
  436.                 c=strrchr(t,'\\');
  437.                 if ( !strcmp(c,"\\*.IMG") ) {
  438.                     *(c+1)=0;
  439.                     strcat(t,"SCR");
  440.                 }
  441.                 else {
  442.                     c=strrchr(t,'.');
  443.                     if ( !strcmp(c,".IMG") )
  444.                         *c=0;
  445.                 }
  446.             }
  447.             objc_draw(dialog,0,10,x,y,w,h);
  448.         }
  449.     } while ( ret==SELECT );
  450.     objc_unselect(dialog,ret);
  451.     undraw_objc(x,y,w,h,&buffer,flag);
  452.     if ( !flag ) {                        /* hintergrund war nicht gesichert */
  453.         wind_update(END_UPDATE);        /* -> gebe aes zeit zum restaurieren */
  454.         evnt_timer(250,0);                /*        des hintergrundes */
  455.         wind_update(BEG_UPDATE);
  456.     }
  457.  
  458.     if ( ret!=CANCEL ) {                /* daten einlesen */
  459.         strcpy(inst.file,objc_tedstr(dialog,PATH));
  460.         if ( objc_selected(dialog,XIMG) )
  461.             inst.ximg=1;
  462.         else
  463.             inst.ximg=0;
  464.  
  465.         if ( objc_selected(dialog,RESET) )
  466.             scr_nr=0;
  467.  
  468. #ifdef GEMDUMP                            /* zus. opt von GEMDUMP */
  469.         if ( inst.althelp && !objc_selected(dialog,ALTHELP) ) {
  470.             inst.althelp=0;
  471.             evnts&=~MU_TIMER;
  472.             exit_vbl();
  473.         }
  474.         else if ( !inst.althelp && objc_selected(dialog,ALTHELP) ) {
  475.             if ( init_vbl() ) {
  476.                 inst.althelp=1;            /* nur wenn init_vbl erfolgreich */
  477.                 evnts|=MU_TIMER;
  478.             }
  479.         }
  480. #endif
  481.     }
  482.  
  483.     err=0;
  484.  
  485.     if ( ret==SAVE ) {                    /* speichern */
  486.       char name[64];
  487.       int f_id;
  488.       long id;
  489.         strcpy(name,PARAM_SAVE);
  490.         if ( get_name(name,PARAM_EXT,"Parameter speichern") ) {
  491.             f_id=Fopen(name,FO_RW);
  492.             Fseek(PAR_OFF,f_id,0);
  493.             Fread(f_id,4,&id);
  494.             if ( id=='TMMW' ) {
  495.                 Fwrite(f_id,sizeof(inst),&inst);
  496.             }
  497.             Fclose(f_id);
  498.         }
  499.     }
  500.                                         /* fenster oder rahmen speichern */
  501.     else if ( ret==WINDOW || ret==DRAG ) {
  502.       long len;
  503.       int mx,my,mb;
  504.       int wi,x,y,w,h,xy[8];
  505.  
  506.         wind_update(BEG_MCTRL);
  507.  
  508.                                         /* ermittle koordinaten */
  509.         if ( ret==WINDOW ) {                /* fenster */
  510.             graf_mouse(POINT_HAND,0l);
  511.             evnt_button(2+3+256,3,0,&mx,&my,&mb,&dummy);
  512.             if ( mb==1 ) {
  513.                 wi=wind_find(mx,my);
  514.                 wind_get(wi,WF_WORKXYWH,&x,&y,&w,&h);
  515.             }
  516.         }
  517.         else {                                /* rahmen */
  518.             graf_mouse(THIN_CROSS,0l);
  519.             evnt_button(2+3+256,3,0,&x,&y,&mb,&dummy);
  520.             if ( mb==1 ) {
  521.                 graf_rubberbox(x,y,-screen_w,-screen_h,&w,&h);
  522.                 if ( w<0 )
  523.                     { x+=w; w=-w; }
  524.                 if ( h<0 )
  525.                     { y+=h; h=-h; }
  526.             }
  527.         }
  528.         graf_mouse(ARROW,0l);
  529.         wind_update(END_MCTRL);
  530.  
  531.                                             /* speichern wenn links-klick */
  532.         if ( mb==1 ) {
  533.             err=-39;                        /* speicherfehler */
  534.                                             /* (wird überschrieben, wenn er nicht eintritt */
  535.             check_recs(0,0,screen_w,screen_h,&x,&y,&w,&h);
  536.             if ( (len=set_fdb(w,h,&buffer))!=0l ) {
  537.                 memset(buffer.fd_addr,0,len);
  538.                 xy[0]=x; xy[1]=y; xy[2]=x+w-1; xy[3]=y+h-1;
  539.                 xy[4]=0; xy[5]=0; xy[6]=w-1; xy[7]=h-1;
  540.                 screen.fd_addr=0;
  541.                 v_hide_c(handle);
  542.                 vro_cpyfm(handle,3,xy,&screen,&buffer);
  543.                 v_show_c(handle,1);
  544.                 _make_name(name);
  545. #ifdef GEMDUMP                                 /* für GEMDUMP: transformiere nach std */
  546.                 { MFDB std;
  547.                   COLOR colors[256];
  548.                     if ( (len=set_fdb(w,h,&std))!=0l ) {
  549.                         std.fd_stand=1;
  550.                         vr_trnfm(handle,&buffer,&std);
  551.                         if ( inst.ximg )
  552.                             get_colors(colors);
  553.                         err=_store_img(name,&std,w,h,colors,inst.ximg);
  554.                         Mfree(std.fd_addr);
  555.                     }
  556.                     Mfree(buffer.fd_addr);
  557.                 }
  558. #else
  559.                 err=_store_img(name,&buffer,w,h,0l,inst.ximg);
  560.                 Mfree(buffer.fd_addr);
  561. #endif
  562.             }
  563.         }
  564.     }
  565.     else if ( ret==SCREEN ) {            /* ganzer bildschirm */
  566. #ifdef GEMDUMP
  567.         err=gem_screen();                        /* gem konform */
  568. #else
  569.         _make_name(name);                    /* xbios/vdi-esc/line-a-vars */
  570.         err=_store_img(name,&screen,0,0,0l,inst.ximg);
  571. #endif
  572.     }
  573.  
  574.     if ( err<0 ) {                        /* fehler ausgeben */
  575.         if ( err==-1000 )
  576.             form_alert(1,"[3][ Schreibfehler! | Platte voll?! | ][Abbruch]");
  577.         else
  578.             form_error(-err-31);
  579.     }
  580.  
  581.     wind_update(END_UPDATE);
  582.     v_clsvwk(handle);
  583. }
  584.  
  585. /*
  586.     acc-schleife
  587. */    
  588. int main(void)
  589. {
  590. int gl_apid,acc_id;
  591. int message[8];
  592. OBJECT *ob;
  593. #ifdef GEMDUMP
  594. int evnt;
  595. #endif
  596.  
  597.         /* anmelden beim aes */
  598.     gl_apid=appl_init();
  599.  
  600.         /* dialog initialisieren */
  601.     dialog=rs_object;
  602.     ob=dialog;
  603.     do {
  604.         rsrc_obfix(ob,0);
  605.     } while ( !(objc_flags(ob++,0)&LASTOB) );
  606.  
  607.  
  608.     /*
  609.         ACC
  610.     */
  611.     if ( !_app ) {
  612.         acc_id=menu_register(gl_apid,MENUE_ENTRY);
  613.                                         /* anmelden */
  614.  
  615. #ifdef GEMDUMP
  616.         if ( inst.althelp ) {            /* alt/help-abfrage einschalten */
  617.             init_vbl();
  618.             evnts|=MU_TIMER;
  619.         }
  620. #endif
  621.  
  622.         while ( TRUE ) {                /* acc-schleife */
  623. #ifdef GEMDUMP                                 /* für GEMDUMP */
  624.             evnt=evnt_multi(evnts, 0,0,0, 0,0,0,0,0, 0,0,0,0,0,
  625.                      message, ev_time,0, &dummy, &dummy,&dummy,&dummy,&dummy,&dummy);
  626.  
  627.                                         /* timer-evnt, althelp flag ein, zeit passt noch */
  628.             if ( evnt&MU_TIMER && althelp && gettimer()-ah_time<200 ) {                    
  629.                 init_vdi();
  630.                 gem_screen();
  631.                 v_clsvwk(handle);
  632.                 althelp=0;
  633.             }
  634.                                         /* acc-aufruf */
  635.             else if ( evnt&MU_MESAG && message[0]==AC_OPEN && message[4]==acc_id ) {
  636.                 do_work();
  637.             }
  638. #else                                        /* für SCRDUMP (kein TIMER_EVNT) */
  639.             evnt_mesag(message);
  640.             if ( message[0]==AC_OPEN && message[4]==acc_id ) {
  641.                 do_work();
  642.             }
  643. #endif
  644.         }
  645.     }
  646.     else {            /* programm */
  647.         graf_mouse(ARROW,0l);
  648.         do_work();
  649.     }
  650.     appl_exit();
  651.     return 0;
  652. }
  653.